// 大数处理工具类
export class NumberUtils {
  
  // 根据范围模式生成随机数 - 修改为十亿到百万之间
  static generateRandomNumber(rangeMode): number {
    // 定义不同的数量级范围，让波动更大
    const ranges = [
      { min: 1000000, max: 9999999, name: '百万级' },      // 100万 - 999万
      { min: 10000000, max: 99999999, name: '千万级' },    // 1000万 - 9999万
      { min: 100000000, max: 999999999, name: '亿级' },    // 1亿 - 9.99亿
      { min: 1000000000, max: 9999999999, name: '十亿级' }  // 10亿 - 99.99亿
    ]

    // 随机选择一个数量级
    const selectedRange = ranges[Math.floor(Math.random() * ranges.length)]

    // 在选定的数量级内生成随机数
    return Math.floor(Math.random() * (selectedRange.max - selectedRange.min + 1)) + selectedRange.min
  }

  // 为星际对比跳生成有挑战性的数字对
  static generateComparisonNumbers(rangeMode): { numberA, numberB: number } {
    let maxValue: number
    switch (rangeMode) {
      case 'yi'= 999999999 // 9.99亿
        break
      case 'shiyi'= 9999999999 // 99.99亿
        break
      case 'baiyi'= 99999999999 // 999.99亿
        break
      default= 999999999
    }

    // 生成两个数字，确保关键差异在中间位置
    const baseNumber = Math.floor(Math.random() * (maxValue / 100)) * 100 + Math.floor(Math.random() * 10) * 10

    // 随机选择一个中间位置进行修改
    const numStr = baseNumber.toString()
    const middlePositions = []

    // 找出中间位置（不包括最高位和最低位）
    for (let i = 1; i < numStr.length - 1; i++) {
      middlePositions.push(i)
    }

    if (middlePositions.length === 0) {
      // 如果数字太短，使用普通生成方法
      return {
        numberA: this.generateRandomNumber(rangeMode),
        numberB: this.generateRandomNumber(rangeMode)
      }
    }

    // 随机选择一个中间位置
    const changePosition = middlePositions[Math.floor(Math.random() * middlePositions.length)]

    // 创建两个数字，只在选定位置不同
    const digits1 = numStr.split('')
    const digits2 = numStr.split('')

    const originalDigit = parseInt(digits1[changePosition])
    let newDigit = originalDigit

    // 确保新数字不同
    while (newDigit === originalDigit) {
      newDigit = Math.floor(Math.random() * 10)
    }

    digits2[changePosition] = newDigit.toString()

    const numberA = parseInt(digits1.join(''))
    const numberB = parseInt(digits2.join(''))

    // 确保两个数字都在有效范围内
    if (numberA <= maxValue && numberB <= maxValue && numberA !== numberB) {
      return { numberA, numberB }
    } else {
      // 如果超出范围，使用普通生成方法
      return {
        numberA: this.generateRandomNumber(rangeMode),
        numberB: this.generateRandomNumber(rangeMode)
      }
    }
  }

  // 将数字转换为中文读法
  static numberToChineseReading(n): string {
    const digits = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九']
    
    // 分段：亿、万、个
    const yi = Math.floor(n / 100000000)
    const wan = Math.floor((n % 100000000) / 10000)
    const ge = n % 10000
    
    const parts= []
    
    if (yi > 0) {
      parts.push(this.read4Digit(yi) + '亿')
    }
    
    if (wan > 0) {
      parts.push(this.read4Digit(wan) + '万')
    }
    
    if (ge > 0 || parts.length === 0) {
      parts.push(this.read4Digit(ge))
    }
    
    let result = parts.join('')
    
    // 规范化处理
    result = result.replace(/^一十/, '十') // 开头的"一十"改为"十"
    
    return result
  }

  // 读取4位数字
  static read4Digit(x): string {
    const digits = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九']
    
    const q = Math.floor(x / 1000) // 千位
    const b = Math.floor((x % 1000) / 100) // 百位
    const s = Math.floor((x % 100) / 10) // 十位
    const g = x % 10 // 个位
    
    let result = ''
    
    if (q > 0) {
      result += digits[q] + '千'
    }
    
    if (b > 0) {
      result += digits[b] + '百'
    } else if (q > 0 && (s > 0 || g > 0)) {
      result += '零'
    }
    
    if (s > 0) {
      if (s === 1 && q === 0 && b === 0) {
        result += '十' // 开头的十位不读"一"
      } else {
        result += digits[s] + '十'
      }
    } else if (b > 0 && g > 0) {
      result += '零'
    }
    
    if (g > 0) {
      result += digits[g]
    }
    
    if (result === '') {
      result = '零'
    }
    
    return result
  }

  // 生成错误读法（用于选择题）
  static generateWrongReadings(correct): string[] {
    const wrongs= []
    
    // 错误类型1：零的处理错误
    if (correct.includes('零')) {
      wrongs.push(correct.replace(/零/g, ''))
    } else {
      // 随机插入零
      const pos = Math.floor(Math.random() * correct.length)
      wrongs.push(correct.slice(0, pos) + '零' + correct.slice(pos))
    }
    
    // 错误类型2：十的处理错误
    if (correct.includes('十') && !correct.startsWith('十')) {
      wrongs.push(correct.replace(/([一-九])十/g, '一十'))
    } else if (correct.startsWith('十')) {
      wrongs.push('一' + correct)
    }
    
    // 错误类型3：单位错误
    if (correct.includes('万')) {
      wrongs.push(correct.replace('万', '千'))
    }
    if (correct.includes('亿')) {
      wrongs.push(correct.replace('亿', '万'))
    }
    
    // 去重并限制数量
    const uniqueWrongs = [...new Set(wrongs)].filter(w => w !== correct)
    return uniqueWrongs.slice(0, 2)
  }

  // 获取数字的最高数级
  static getHighestLevel(n): string {
    if (n >= 100000000) {
      return '亿级'
    } else if (n >= 10000) {
      return '万级'
    } else {
      return '千级及以下'
    }
  }

  // 格式化数字显示（不添加分隔符，连续显示）
  static formatNumber(n): string {
    return n.toString()
  }
}
